home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_logging.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  13KB  |  410 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Test harness for the logging module. Run all tests.
  5.  
  6. Copyright (C) 2001-2002 Vinay Sajip. All Rights Reserved.
  7. '''
  8. import select
  9. import os
  10. import sys
  11. import string
  12. import struct
  13. import types
  14. import cPickle
  15. import cStringIO
  16. import socket
  17. import threading
  18. import time
  19. import logging
  20. import logging.handlers as logging
  21. import logging.config as logging
  22. BANNER = '-- %-10s %-6s ---------------------------------------------------\n'
  23. FINISH_UP = "Finish up, it's closing time. Messages should bear numbers 0 through 24."
  24. TIMEOUT = 10
  25. from SocketServer import ThreadingTCPServer, StreamRequestHandler
  26.  
  27. class LogRecordStreamHandler(StreamRequestHandler):
  28.     '''
  29.     Handler for a streaming logging request. It basically logs the record
  30.     using whatever logging policy is configured locally.
  31.     '''
  32.     
  33.     def handle(self):
  34.         '''
  35.         Handle multiple requests - each expected to be a 4-byte length,
  36.         followed by the LogRecord in pickle format. Logs the record
  37.         according to whatever policy is configured locally.
  38.         '''
  39.         while None:
  40.             
  41.             try:
  42.                 chunk = self.connection.recv(4)
  43.                 if len(chunk) < 4:
  44.                     break
  45.                 
  46.                 slen = struct.unpack('>L', chunk)[0]
  47.                 chunk = self.connection.recv(slen)
  48.                 while len(chunk) < slen:
  49.                     chunk = chunk + self.connection.recv(slen - len(chunk))
  50.                 obj = self.unPickle(chunk)
  51.                 record = logging.makeLogRecord(obj)
  52.                 self.handleLogRecord(record)
  53.             continue
  54.             raise 
  55.             continue
  56.  
  57.  
  58.     
  59.     def unPickle(self, data):
  60.         return cPickle.loads(data)
  61.  
  62.     
  63.     def handleLogRecord(self, record):
  64.         logname = 'logrecv.tcp.' + record.name
  65.         if record.msg == FINISH_UP:
  66.             self.server.abort = 1
  67.         
  68.         record.msg = record.msg + ' (via ' + logname + ')'
  69.         logger = logging.getLogger(logname)
  70.         logger.handle(record)
  71.  
  72.  
  73. socketDataProcessed = threading.Event()
  74.  
  75. class LogRecordSocketReceiver(ThreadingTCPServer):
  76.     '''
  77.     A simple-minded TCP socket-based logging receiver suitable for test
  78.     purposes.
  79.     '''
  80.     allow_reuse_address = 1
  81.     
  82.     def __init__(self, host = 'localhost', port = logging.handlers.DEFAULT_TCP_LOGGING_PORT, handler = LogRecordStreamHandler):
  83.         ThreadingTCPServer.__init__(self, (host, port), handler)
  84.         self.abort = 0
  85.         self.timeout = 1
  86.  
  87.     
  88.     def serve_until_stopped(self):
  89.         abort = 0
  90.         while not abort:
  91.             (rd, wr, ex) = select.select([
  92.                 self.socket.fileno()], [], [], self.timeout)
  93.             if rd:
  94.                 self.handle_request()
  95.             
  96.             abort = self.abort
  97.         socketDataProcessed.set()
  98.  
  99.     
  100.     def process_request(self, request, client_address):
  101.         t = threading.Thread(target = self.finish_request, args = (request, client_address))
  102.         t.start()
  103.  
  104.  
  105.  
  106. def runTCP(tcpserver):
  107.     tcpserver.serve_until_stopped()
  108.  
  109. msgcount = 0
  110.  
  111. def nextmessage():
  112.     global msgcount
  113.     rv = 'Message %d' % msgcount
  114.     msgcount = msgcount + 1
  115.     return rv
  116.  
  117.  
  118. def test0():
  119.     ERR = logging.getLogger('ERR')
  120.     ERR.setLevel(logging.ERROR)
  121.     INF = logging.getLogger('INF')
  122.     INF.setLevel(logging.INFO)
  123.     INF_ERR = logging.getLogger('INF.ERR')
  124.     INF_ERR.setLevel(logging.ERROR)
  125.     DEB = logging.getLogger('DEB')
  126.     DEB.setLevel(logging.DEBUG)
  127.     INF_UNDEF = logging.getLogger('INF.UNDEF')
  128.     INF_ERR_UNDEF = logging.getLogger('INF.ERR.UNDEF')
  129.     UNDEF = logging.getLogger('UNDEF')
  130.     GRANDCHILD = logging.getLogger('INF.BADPARENT.UNDEF')
  131.     CHILD = logging.getLogger('INF.BADPARENT')
  132.     ERR.log(logging.FATAL, nextmessage())
  133.     ERR.error(nextmessage())
  134.     INF.log(logging.FATAL, nextmessage())
  135.     INF.error(nextmessage())
  136.     INF.warn(nextmessage())
  137.     INF.info(nextmessage())
  138.     INF_UNDEF.log(logging.FATAL, nextmessage())
  139.     INF_UNDEF.error(nextmessage())
  140.     INF_UNDEF.warn(nextmessage())
  141.     INF_UNDEF.info(nextmessage())
  142.     INF_ERR.log(logging.FATAL, nextmessage())
  143.     INF_ERR.error(nextmessage())
  144.     INF_ERR_UNDEF.log(logging.FATAL, nextmessage())
  145.     INF_ERR_UNDEF.error(nextmessage())
  146.     DEB.log(logging.FATAL, nextmessage())
  147.     DEB.error(nextmessage())
  148.     DEB.warn(nextmessage())
  149.     DEB.info(nextmessage())
  150.     DEB.debug(nextmessage())
  151.     UNDEF.log(logging.FATAL, nextmessage())
  152.     UNDEF.error(nextmessage())
  153.     UNDEF.warn(nextmessage())
  154.     UNDEF.info(nextmessage())
  155.     GRANDCHILD.log(logging.FATAL, nextmessage())
  156.     CHILD.log(logging.FATAL, nextmessage())
  157.     ERR.warn(nextmessage())
  158.     ERR.info(nextmessage())
  159.     ERR.debug(nextmessage())
  160.     INF.debug(nextmessage())
  161.     INF_UNDEF.debug(nextmessage())
  162.     INF_ERR.warn(nextmessage())
  163.     INF_ERR.info(nextmessage())
  164.     INF_ERR.debug(nextmessage())
  165.     INF_ERR_UNDEF.warn(nextmessage())
  166.     INF_ERR_UNDEF.info(nextmessage())
  167.     INF_ERR_UNDEF.debug(nextmessage())
  168.     INF.info(FINISH_UP)
  169.  
  170. SILENT = 10
  171. TACITURN = 9
  172. TERSE = 8
  173. EFFUSIVE = 7
  174. SOCIABLE = 6
  175. VERBOSE = 5
  176. TALKATIVE = 4
  177. GARRULOUS = 3
  178. CHATTERBOX = 2
  179. BORING = 1
  180. LEVEL_RANGE = range(BORING, SILENT + 1)
  181. my_logging_levels = {
  182.     SILENT: 'Silent',
  183.     TACITURN: 'Taciturn',
  184.     TERSE: 'Terse',
  185.     EFFUSIVE: 'Effusive',
  186.     SOCIABLE: 'Sociable',
  187.     VERBOSE: 'Verbose',
  188.     TALKATIVE: 'Talkative',
  189.     GARRULOUS: 'Garrulous',
  190.     CHATTERBOX: 'Chatterbox',
  191.     BORING: 'Boring' }
  192.  
  193. class SpecificLevelFilter(logging.Filter):
  194.     
  195.     def __init__(self, lvl):
  196.         self.level = lvl
  197.  
  198.     
  199.     def filter(self, record):
  200.         return self.level != record.levelno
  201.  
  202.  
  203.  
  204. class GarrulousFilter(SpecificLevelFilter):
  205.     
  206.     def __init__(self):
  207.         SpecificLevelFilter.__init__(self, GARRULOUS)
  208.  
  209.  
  210.  
  211. class VerySpecificFilter(logging.Filter):
  212.     
  213.     def filter(self, record):
  214.         return record.levelno not in [
  215.             SOCIABLE,
  216.             TACITURN]
  217.  
  218.  
  219.  
  220. def message(s):
  221.     sys.stdout.write('%s\n' % s)
  222.  
  223. SHOULD1 = "This should only be seen at the '%s' logging level (or lower)"
  224.  
  225. def test1():
  226.     for lvl in my_logging_levels.keys():
  227.         logging.addLevelName(lvl, my_logging_levels[lvl])
  228.     
  229.     
  230.     def doLog(log):
  231.         for lvl in LEVEL_RANGE:
  232.             log.log(lvl, SHOULD1, logging.getLevelName(lvl))
  233.         
  234.  
  235.     log = logging.getLogger('')
  236.     hdlr = log.handlers[0]
  237.     for lvl in LEVEL_RANGE:
  238.         message("-- setting logging level to '%s' -----" % logging.getLevelName(lvl))
  239.         log.setLevel(lvl)
  240.         doLog(log)
  241.     
  242.     hdlr.setLevel(SOCIABLE)
  243.     message('-- Filtering at handler level to SOCIABLE --')
  244.     for lvl in LEVEL_RANGE:
  245.         message("-- setting logging level to '%s' -----" % logging.getLevelName(lvl))
  246.         log.setLevel(lvl)
  247.         doLog(log)
  248.     
  249.     hdlr.setLevel(0)
  250.     garr = GarrulousFilter()
  251.     hdlr.addFilter(garr)
  252.     message('-- Filtering using GARRULOUS filter --')
  253.     for lvl in LEVEL_RANGE:
  254.         message("-- setting logging level to '%s' -----" % logging.getLevelName(lvl))
  255.         log.setLevel(lvl)
  256.         doLog(log)
  257.     
  258.     spec = VerySpecificFilter()
  259.     log.addFilter(spec)
  260.     message('-- Filtering using specific filter for SOCIABLE, TACITURN --')
  261.     for lvl in LEVEL_RANGE:
  262.         message("-- setting logging level to '%s' -----" % logging.getLevelName(lvl))
  263.         log.setLevel(lvl)
  264.         doLog(log)
  265.     
  266.     log.removeFilter(spec)
  267.     hdlr.removeFilter(garr)
  268.     logging.addLevelName(logging.DEBUG, 'DEBUG')
  269.  
  270. MSG = '-- logging %d at INFO, messages should be seen every 10 events --'
  271.  
  272. def test2():
  273.     logger = logging.getLogger('')
  274.     sh = logger.handlers[0]
  275.     sh.close()
  276.     logger.removeHandler(sh)
  277.     mh = logging.handlers.MemoryHandler(10, logging.WARNING, sh)
  278.     logger.setLevel(logging.DEBUG)
  279.     logger.addHandler(mh)
  280.     message('-- logging at DEBUG, nothing should be seen yet --')
  281.     logger.debug('Debug message')
  282.     message('-- logging at INFO, nothing should be seen yet --')
  283.     logger.info('Info message')
  284.     message('-- logging at WARNING, 3 messages should be seen --')
  285.     logger.warn('Warn message')
  286.     for i in xrange(102):
  287.         message(MSG % i)
  288.         logger.info('Info index = %d', i)
  289.     
  290.     mh.close()
  291.     logger.removeHandler(mh)
  292.     logger.addHandler(sh)
  293.  
  294. FILTER = 'a.b'
  295.  
  296. def doLog3():
  297.     logging.getLogger('a').info('Info 1')
  298.     logging.getLogger('a.b').info('Info 2')
  299.     logging.getLogger('a.c').info('Info 3')
  300.     logging.getLogger('a.b.c').info('Info 4')
  301.     logging.getLogger('a.b.c.d').info('Info 5')
  302.     logging.getLogger('a.bb.c').info('Info 6')
  303.     logging.getLogger('b').info('Info 7')
  304.     logging.getLogger('b.a').info('Info 8')
  305.     logging.getLogger('c.a.b').info('Info 9')
  306.     logging.getLogger('a.bb').info('Info 10')
  307.  
  308.  
  309. def test3():
  310.     root = logging.getLogger()
  311.     root.setLevel(logging.DEBUG)
  312.     hand = root.handlers[0]
  313.     message('Unfiltered...')
  314.     doLog3()
  315.     message("Filtered with '%s'..." % FILTER)
  316.     filt = logging.Filter(FILTER)
  317.     hand.addFilter(filt)
  318.     doLog3()
  319.     hand.removeFilter(filt)
  320.  
  321.  
  322. def banner(nm, typ):
  323.     sep = BANNER % (nm, typ)
  324.     sys.stdout.write(sep)
  325.     sys.stdout.flush()
  326.  
  327.  
  328. def test_main_inner():
  329.     rootLogger = logging.getLogger('')
  330.     rootLogger.setLevel(logging.DEBUG)
  331.     hdlr = logging.StreamHandler(sys.stdout)
  332.     fmt = logging.Formatter(logging.BASIC_FORMAT)
  333.     hdlr.setFormatter(fmt)
  334.     rootLogger.addHandler(hdlr)
  335.     shdlr = logging.handlers.SocketHandler('localhost', logging.handlers.DEFAULT_TCP_LOGGING_PORT)
  336.     sockOut = cStringIO.StringIO()
  337.     sockLogger = logging.getLogger('logrecv')
  338.     sockLogger.setLevel(logging.DEBUG)
  339.     sockhdlr = logging.StreamHandler(sockOut)
  340.     sockhdlr.setFormatter(logging.Formatter('%(name)s -> %(levelname)s: %(message)s'))
  341.     sockLogger.addHandler(sockhdlr)
  342.     sockLogger.propagate = 0
  343.     threads = []
  344.     tcpserver = LogRecordSocketReceiver()
  345.     threads.append(threading.Thread(target = runTCP, args = (tcpserver,)))
  346.     for thread in threads:
  347.         thread.start()
  348.     
  349.     
  350.     try:
  351.         banner('log_test0', 'begin')
  352.         rootLogger.addHandler(shdlr)
  353.         test0()
  354.         shdlr.close()
  355.         rootLogger.removeHandler(shdlr)
  356.         banner('log_test0', 'end')
  357.         banner('log_test1', 'begin')
  358.         test1()
  359.         banner('log_test1', 'end')
  360.         banner('log_test2', 'begin')
  361.         test2()
  362.         banner('log_test2', 'end')
  363.         banner('log_test3', 'begin')
  364.         test3()
  365.         banner('log_test3', 'end')
  366.     finally:
  367.         socketDataProcessed.wait()
  368.         for thread in threads:
  369.             thread.join()
  370.         
  371.         banner('logrecv output', 'begin')
  372.         sys.stdout.write(sockOut.getvalue())
  373.         sockOut.close()
  374.         sockLogger.removeHandler(sockhdlr)
  375.         sockhdlr.close()
  376.         banner('logrecv output', 'end')
  377.         sys.stdout.flush()
  378.         
  379.         try:
  380.             hdlr.close()
  381.         except:
  382.             pass
  383.  
  384.         rootLogger.removeHandler(hdlr)
  385.  
  386.  
  387.  
  388. def test_main():
  389.     import locale as locale
  390.     
  391.     try:
  392.         original_locale = locale.setlocale(locale.LC_ALL)
  393.         locale.setlocale(locale.LC_ALL, '')
  394.     except (ValueError, locale.Error):
  395.         original_locale = None
  396.  
  397.     
  398.     try:
  399.         test_main_inner()
  400.     finally:
  401.         if original_locale is not None:
  402.             locale.setlocale(locale.LC_ALL, original_locale)
  403.         
  404.  
  405.  
  406. if __name__ == '__main__':
  407.     sys.stdout.write('test_logging\n')
  408.     test_main()
  409.  
  410.